/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.rm.beans;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.rm.entidades.*;
import org.rm.entidades.jpa.*;
import org.rm.entidades.jpa.exceptions.NonexistentEntityException;

/**
 *
 * @author ffbeltran
 */
public class ControladorBeans {

    private int idPartida;
    private int idPartidaMax;
    private List<Jugadores> jugadores;
    private Jugadores jugador;
    private Map<String,ExperienciaBase> entidadesBase;
    private Map<String,List> listasExperiencias;

    public ControladorBeans() {
        idPartida = PartidaJpaController.getMaxIdPartida();
        idPartidaMax = idPartida;
        jugadores = JugadoresJpaController.findJugadoresEntities();
        
        inicializaListas();
        inicializaBeans();
    }
    
    public void inicializaListas() {
        listasExperiencias = new HashMap<String,List>();
        for (String nombre : ControladorUtil.getNombresEntidades()) {
            Class clase = ControladorUtil.getEntidad(nombre);
            listasExperiencias.put(nombre,
                    JpaExperiencia.findExperienciaBaseEntities(clase, idPartida));
        }
    }
    
    public void inicializaBeans() {
        jugador = new Jugadores();
        entidadesBase = new HashMap<String,ExperienciaBase>();
        for (String nombre : ControladorUtil.getNombresEntidades()) {
            try {
                Class clase = ControladorUtil.getEntidad(nombre);
                entidadesBase.put(nombre, (ExperienciaBase) clase.newInstance());
            } catch (InstantiationException ex) {
                ex.printStackTrace();
            } catch (IllegalAccessException ex) {
                ex.printStackTrace();
            }
        }
    }

    public void setListaExperiencia(String nombre, List experiencias) {
        listasExperiencias.put(nombre, experiencias);
    }

    public List getListaExperiencia(String nombre) {
        return listasExperiencias.get(nombre);
    }

    public Map<String,List> getListasExperiencias() {
        return listasExperiencias;
    }

    public Map<String,ExperienciaBase> getEntidadesBase() {
        return entidadesBase;
    }

    public Map<String,Integer> getTamanyoListas() {
        Map<String,Integer> numElemlistas = new HashMap<String,Integer>();
        for (String nombre : listasExperiencias.keySet()) {
            numElemlistas.put(nombre, listasExperiencias.get(nombre).size());
        }
        return numElemlistas;
    }

    public void calculaExperiencia(Exp experiencia) {
        List<Exp> expList = new ArrayList<Exp>();
        expList.add(experiencia);
        calculaExperiencia(expList);
    }

    public void calculaExperiencia(List<? extends Exp> experiencia) {
    	Map<Partida, Integer> expCompartida = new HashMap<Partida, Integer>();
    	
    	for (Partida aux : PartidaJpaController.findPartidaEntities()) {
    		expCompartida.put(aux, 0);
		}
        
        for (Iterator<Jugadores> it = jugadores.iterator(); it.hasNext();) {
            Jugadores jugadorActual = it.next();
            for (Iterator<? extends Exp> it2 = experiencia.iterator(); it2.hasNext();) {
                Exp exp = it2.next();
                if(exp.getJugador().equals(jugadorActual)) {
                    int expSign = (exp.getExp()>=0)?1:-1;
                    int expAbs = Math.abs(exp.getExp());
                    int expComp = (int) Math.ceil(((double) expAbs * exp.getCompartido() / 100));
                    int expJugador = (expAbs - expComp) * expSign;
                    expComp = (int) Math.ceil((double) expComp / jugadores.size());
                    Partida partida = PartidaJpaController.findPartida(exp.getIdPartida());
                    ControladorUtil.addExpJugador(jugadorActual, expJugador, partida);
                    Integer aux = expCompartida.get(partida);
                    expCompartida.put(partida,aux + (expComp * expSign));
                }
            }
        }
        
        for (Partida partida : expCompartida.keySet()) {
			int expCompartidaGeneral = expCompartida.get(partida);
			for (Iterator<Jugadores> it = jugadores.iterator(); it.hasNext();) {
				Jugadores jugadorActual = it.next();
				ControladorUtil.addExpJugador(jugadorActual, expCompartidaGeneral, partida);
			}
		}
    }

    // TODO Este método deberá encargarse de seleccionar una partida determinada. Actualmente sólo puede modificarse la última partida
    public String seleccionaPartida() {
        inicializaListas();
        inicializaBeans();
        return "exito";
    }

    public String grabaPartida() {
        Partida p = new Partida();
        PartidaJpaController.create(p);
        idPartida = PartidaJpaController.getMaxIdPartida();
        inicializaListas();
        inicializaBeans();
        
        for (Iterator<Jugadores> it = jugadores.iterator(); it.hasNext();) {
            Jugadores jug = it.next();
            jug.getExperiencia().add(new ExParcial(0, p));
            try {
                JugadoresJpaController.edit(jug);

            } catch (NonexistentEntityException ex) {
                ex.printStackTrace();
            } catch (Exception ex) {
                ex.printStackTrace();
            }                       
        }
        
        return null;
    }

    public String modificaJugador() {
        Integer id = Integer.valueOf(ControladorUtil.getParam("id"));
        for (Iterator<Jugadores> it = jugadores.iterator(); it.hasNext();) {
            Jugadores jug = it.next();
            if (jug.getId().equals(id)) {
                try {
                    JugadoresJpaController.edit(jug);
                    jugadores = JugadoresJpaController.findJugadoresEntities();
                } catch (NonexistentEntityException ex) {
                    ex.printStackTrace();
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                break;
            }
        }
        return null;
    }

    public String nuevoJugador() {
        jugador.setId(null);
        JugadoresJpaController.create(jugador);
        jugador = new Jugadores();
        jugadores = JugadoresJpaController.findJugadoresEntities();
        return null;
    }

    public String eliminaJugador() {
        String id = ControladorUtil.getParam("id");
        try {
            JugadoresJpaController.destroy(Integer.valueOf(id));
            jugadores = JugadoresJpaController.findJugadoresEntities();
        } catch (NonexistentEntityException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public List<Jugadores> getJugadores() {
        return jugadores;
    }

    public void setJugadores(List<Jugadores> jugadores) {
        this.jugadores = jugadores;
    }

    public Jugadores getJugador() {
        return jugador;
    }

    public void setJugador(Jugadores jugador) {
        this.jugador = jugador;
    }

    public int getIdPartida() {
        return idPartida;
    }

    public void setIdPartida(int idPartida) {
        this.idPartida = idPartida;
    }

    public String getNumeroJugadores() {
        return Integer.toString(jugadores.size());
    }
}
